// poj2417
// 题意：求A^x == B(mod P)，A, B, P给定，P是素数，求最小x。
//
// 题解：baby step giant step, bsgs.
//       将x拆分，x = i * m + j, 那么
//       A^x == B(mod P) ==> A^(i*m) * A^j == B(mod P） 也即
//       D^i * A^j == B(mod p)，其中 D = A^m，预先处理出每个A^j (j [0, m))
//       塞到hash表里。现在只需要对从小到大枚举i，那么相当于求解
//       A' * X == b(mod P)，其中A' = D^i, X = A^j，这是单元线性模方程，
//       这道题P是素数，比较特殊（好做）。
//       解出X之后判断hash表里有对应的A^j，如果有答案就是对应的i * m + j，
//       否则继续。一直没有就没有解。分析下时间复杂度，共进行n/m次小步，
//       O( (n/m)*(log(P)+hash) + m)，取m=sqrt(n)左右比较合适，
//       复杂度为O( sqrt(n)*k )
//       
//
// run: $exec < input
#include <cstdio>
#include <cstring>
#include <cmath>

typedef long long value_type;
value_type a, b, p; // a ^ x == b (mod p)

namespace hash
{
	int const maxlen = 1299721;
	bool hashed[maxlen];
	value_type key[maxlen];
	int value[maxlen];

	void init()
	{
		std::memset(hashed, 0, sizeof(hashed));
		std::memset(key, 0, sizeof(key));
	}

	void insert(value_type k, int v)
	{
		int i = k % maxlen;
		for (; hashed[i] && key[i] != k; i = (i + 1) % maxlen);
		if (!hashed[i]) { hashed[i] = true; key[i] = k; value[i] = v; }
	}

	int find(value_type k)
	{
		value_type i = k % maxlen;
		for (; hashed[i] && key[i] != k; i = (i + 1) % maxlen);
		if (!hashed[i]) return -1;
		return value[i];
	}
};

value_type euler_totient(int x) // this case x is a prime
{
	return x - 1;
}

void extended_gcd(value_type a,  value_type b, value_type & d, value_type & x, value_type & y)
{
	if (!b) { d = a; x = 1; y = 0; }
	else {
		extended_gcd(b, a % b, d, y, x);
		y -= x * (a/b);
	}
}

// univariate_modular_system_of_linear_equation
value_type umsole(value_type a, value_type b, value_type p)
{
	// a*x  is congruent to  b  modulo  p
	// => a*x + p*(-y) = b
	value_type x, y, b0;
	extended_gcd(a, p, b0, x, y);
	value_type m = p / b0;
	return ((x * (b / b0)) % m + m) % m;
}

value_type baby_step_giant_step(value_type a, value_type b, value_type p)
{
	value_type m = std::ceil(std::sqrt((double)euler_totient(p)));
	hash::init();
	value_type d = 1;
	for (int i = 0; i < m; i++) {
		hash::insert(d, i);
		d = (d * a) % p;
	}

	// now d = a^m
	value_type di = 1; // d^i
	for (int i = 0; i < m; i++) {
		value_type x = umsole(di, b, p);
		int tmp  = hash::find(x);
		if (tmp != -1)
			return i * m + tmp;
		di = (di * d) % p;
	}
	return -1;
}

int main()
{
	while (std::scanf("%lld %lld %lld", &p, &a, &b) != EOF) {
		value_type ans = baby_step_giant_step(a, b, p);
		if (ans == -1) std::printf("no solution\n");
		else		   std::printf("%lld\n", ans);
	}
}

